/**
 * 验证模块
 */
const test = {};

// 非空 {name: {required: true}}
test.required = (value, blen, str) => {
  let valueType = Object.prototype.toString.call(value); // 值类型
  if (blen) {
    switch (valueType){
      case '[object Array]':
        return value.length === 0 ? ` ${str}不能为空` : null;
      case '[object Object]':
        return JSON.stringify(value) === '{}' ? ` ${str}不能为空` : null;
      default:
        return typeof value !== 'undefined' && value !== null && value !== '' ? null : ` ${str}不能为空`;
    }
  }
  return null;
}

// 长度 {name: {length: [min, max]}} || {name: {length: [length]}}
test.length = (value, lengthList, str) => {
  // 值为空直接返回
  if (typeof value === 'undefined' || value === null || value === '') {
    return null;
  }
  // 如lengthList类型非数组抛出异常
  if (!Array.isArray(lengthList)) {
    throw new Error('lengthList Type Not Array');
  }
  if (lengthList.length === 1) {
    lengthList.push(lengthList[0]);
  }
  let valueL = value.toString().length;
  if (valueL >= lengthList[0] && valueL <= lengthList[1]) {
    return null;
  } else {
    return ` ${str}长度范围${lengthList[0]}-${lengthList[1]}`;
  }
}

// 类型 {name: {type: 'number'}}
test.type = (value, type, str) => {
  // 值为空直接返回
  if (typeof value === 'undefined' || value === null || value === '') {
    return null;
  }
  let valueType = Object.prototype.toString.call(value); // 值类型
  // 判断
  switch (type){
    case 'number':
      return typeof value === 'number' && !isNaN(value) ? null : ` ${str}需要数字类型`;
    case 'string':
      return typeof value === 'string' ? null : ` ${str}需要字符串类型`;
    case 'boolean':
      return typeof value === 'boolean' ? null : ` ${str}需要布尔类型`;
    case 'array':
      return valueType === '[object Array]' ? null : ` ${str}需要数组类型`;
    case 'object':
      return valueType === '[object Object]' ? null : ` ${str}需要对象类型`;
  }
  return null;
}

/**
 * 验证对象
 * @param {Object} datas 数据
 * @param {Object} rule 规则
 */
let validate = (datas, rules) => {
  let msgs = [];
  // 循环规则对象
  for (let dataKey in rules) {
    let data = datas[dataKey]; // 数据-数据中dataKey匹配
    let rule = rules[dataKey]; // 规则组-规则中dataKey匹配
    // 循环规则组
    for (let ruleKey in rule) {
      if (ruleKey !== 'str') { // 排除对象中的str(字段命名成)属性
        let msg = test[ruleKey](data, rule[ruleKey], rule.str ? rule.str : dataKey); // 根据规则名称调用test验证函数
        if (msg) {
          msgs.push(msg);
        }
      }
    }
  }
  return msgs.length > 0 ? msgs : null;
}

module.exports = validate;
